#include "Contains.h"


Contains::Contains()
{
	_list = vector<TNode>();
	_table = vector<pair<int, int>>();
	_starTable = vector<pair<int,int>>();
	_tSize = 0;
	_lSize = 0;
	_sSize = 0;
}

int Contains::createNode(string nodeType, int index, int procLine) {
//	cout << nodeType << "  " << index << "  " << procLine << endl;
	for (int i=0; i<_lSize; i++) {
		TNode temp = _list.at(i);
		if ((temp.getNodeType().compare(nodeType)==0) && (temp.getIndex()==index) && (temp.getProcLine() == procLine)) {
			return i;
		} 
	}
	TNode newNode = TNode();
	newNode.setNodeType(nodeType);
	newNode.setIndex(index);
	newNode.setProcLine(procLine);
	_list.push_back(newNode);
	_lSize++;
	return _lSize-1;
}

int Contains::insertContains(string nodeType1, int index1, int procLine1, string nodeType2, int index2, int procLine2) {
	int p_id = createNode(nodeType1, index1, procLine1);
	int c_id = createNode(nodeType2, index2, procLine2);
	for (int i=0; i<_tSize; i++) {
		if ((_table.at(i).first == p_id) && (_table.at(i).second == c_id)) {
			return i;
		}		
	}
	pair<int, int> p = pair<int,int>(p_id, c_id);
	_table.push_back(p);
	_tSize++;
	return _tSize-1;
}

int Contains::insertContainsStar(string nodeType1, int index1, int procLine1, string nodeType2, int index2, int procLine2) {
	int p_id = createNode(nodeType1, index1, procLine1);
	int c_id = createNode(nodeType2, index2, procLine2);
	for (int i=0; i<_sSize; i++) {
		if ((_starTable.at(i).first == p_id) && (_starTable.at(i).second == c_id)) {
			return i;
		}		
	}
	pair<int, int> p = pair<int,int>(p_id, c_id);
	_starTable.push_back(p);
	_sSize++;
	return _sSize-1;
}

int Contains::getSize() {
	return _tSize;
}

int Contains::getLSize() {
	return _lSize;
}

int Contains::getSSize() {
	return _sSize;
}

vector<TNode> Contains::getList() {
	return _list;
}

vector<pair<int,int>> Contains::getContains() {
	return _table;
}

vector<pair<int,int>> Contains::getContainsStar() {
	return _starTable;
}

vector<TNode> Contains::searchByType(string nodeType) {
	vector<TNode> result;
	for (int i=0; i<_lSize; i++) {
		if (_list.at(i).getNodeType().compare(nodeType)==0) {
			result.push_back(_list.at(i));
		}
	}
	return result;
}

vector<TNode> Contains::searchByIndex(string nodeType, int index) {
	vector<TNode> result;
	for (int i=0; i<_lSize; i++) {
		TNode temp = _list.at(i);
		if ((temp.getNodeType().compare(nodeType)==0) && 
			(temp.getIndex()==index)) {
				result.push_back(temp);
		}
	}	
	return result;
}

vector<TNode> Contains::searchByProcline(int procLine) {
	vector<TNode> result;
	for (int i=0; i<_lSize; i++) {
		TNode temp = _list.at(i);
		if (temp.getProcLine()==procLine) {
			result.push_back(temp);
		}
	}
	return result;
}

int Contains::getIndex(TNode aim) {
	for (int i=0; i<_lSize; i++) {
		TNode temp = _list.at(i);
		if ((temp.getNodeType().compare(aim.getNodeType())==0) && (temp.getIndex() == aim.getIndex()) && (temp.getProcLine() == aim.getProcLine())) {
			return i;
		}
	}
	return -1;
}

TNode Contains::getNode(int index) {
	return _list.at(index);
}

vector<TNode> Contains::getParent(int index) {
	vector<TNode> result;
	for (int i=0; i<_tSize; i++) {
		if (_table.at(i).second==index) {
			int p_id = _table.at(i).first;
			result.push_back(_list.at(p_id));
		}
	}
	return result;
}

vector<TNode> Contains::getParentStar(int index) {
	vector<TNode> result;
	for (int i=0; i<_sSize; i++) {
		if (_starTable.at(i).second==index) {
			int p_id = _starTable.at(i).first;
			result.push_back(_list.at(p_id));
		}
	}
	return result;
}

vector<TNode> Contains::getChild(int index) {
	vector<TNode> result;
	for (int i=0; i<_tSize; i++) {
		if (_table.at(i).first==index) {
			int c_id = _table.at(i).second;
			result.push_back(_list.at(c_id));
		}
	}
	return result;
}

bool inVector(int e1, int e2, vector<pair<int,int>> v) {
	for (int i=0; i<v.size(); i++) {
		if ((v.at(i).first==e1) && (v.at(i).second==e2)) {
			return true;
		}
	}
	return false;
}
/*
void Contains::computeContainsStar() {
	_starTable = _table;
	_sSize = _tSize;
	for (int k=0; k<_lSize; k++) {
		for (int i=0; i<_lSize; i++) {
			for (int j=0; j<_lSize; j++) {
				if ((!inVector(i,j,_starTable)) && (inVector(i,k, _starTable) && (inVector(k, j, _starTable)))) {
					_starTable.push_back(pair<int,int>(i,j));
					_sSize++;
				}
			}
		}
	}
}*/